!pip install pearsonr
!pip install sklearn
# Importing libraies required
import warnings
warnings.filterwarnings('ignore')
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.stats import ttest_ind
from scipy.stats import f_oneway
from scipy.stats import spearmanr
from sklearn.preprocessing import MinMaxScaler
from sklearn.linear_model import LinearRegression
from sklearn.linear_model import Lasso
from sklearn.linear_model import Ridge
from sklearn.linear_model import ElasticNet
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LassoCV
from sklearn.linear_model import RidgeCV
from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from sklearn.datasets import make_regression
from scipy.stats import uniform
from sklearn.metrics import mean_squared_error
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
# Reading the data set
bikeShare = pd.read_csv("days.csv")
bikeShare.head()
bikeShare.shape
bikeShare.info()
bikeShare.describe()
# Checking for Null Values
bikeShare.isnull().sum()
# Checking for unique values
bikeShare.nunique()
# Renaming columns for better readablity
bikeShare.rename(columns={'yr':'year','mnth':'month','weathersit':'weather_situation','atemp':'temp_feel',
'hum':'humidity','cnt':'count'}, inplace=True)
bikeShare.head()
season_codes = {1:'spring', 2:'summer', 3:'fall', 4:'winter'}
bikeShare['season'] = bikeShare['season'].map(season_codes)
bikeShare.season.head()
month_codes = {1:'January', 2:'February', 3:'March', 4:'April', 5:'May', 6:'June', 7:'July', 8:'August', 9:'September', 10:'October', 11:'November', 12:'December'}
bikeShare['month'] = bikeShare['month'].map(month_codes)
bikeShare.month.head()
weekday_codes = {0:'Monday', 1:'Tuesday', 2:'Wednesday', 3:'Thursday', 4:'Friday', 5:'Saturday', 6:'Sunday'}
bikeShare['weekday'] = bikeShare['weekday'].map(weekday_codes)
bikeShare.weekday.head()
weathersit_codes = {1:'Clear', 2:'Mist', 3:'Light Snow', 4:'Heavy Rain'}
bikeShare['weather_situation'] = bikeShare['weather_situation'].map(weathersit_codes)
bikeShare.weather_situation.head()
yr_codes = {0:"2011",1:"2012"}
bikeShare['year'] = bikeShare['year'].map(yr_codes)
bikeShare.year.head()
bikeShare.head()
# Dropping the above column as it is of no use to us
bikeShare = bikeShare[['season', 'year', 'month', 'holiday', 'weekday', 'workingday', 'weather_situation', 'temp', 'temp_feel', 'humidity', 'windspeed', 'casual', 'registered', 'count']]
bikeShare.head()
bikeShare.info()
# Outlier Detection
# Plot the boxplot of temp variable.
plt.figure(figsize = [8,2])
sns.boxplot(bikeShare.temp)
plt.title("Distribution of temperature", fontsize = 12, color = "brown")
plt.show()
# Plot the boxplot of temp_feel variable.
plt.figure(figsize = [8,2])
sns.boxplot(bikeShare.temp_feel)
plt.title("Distribution of temperature feeeling", fontsize = 12, color = "brown")
plt.show()
# Plot the boxplot of humidity variable.
plt.figure(figsize = [8,2])
sns.boxplot(bikeShare.humidity)
plt.title("Distribution of humidity", fontsize = 12, color = "brown")
plt.show()
# Calculate the IQR (Interquartile Range)
Q1 = bikeShare.humidity.quantile(0.25)
Q3 = bikeShare.humidity.quantile(0.75)
IQR = Q3 - Q1
# Define a threshold for outliers
threshold = 1.5 * IQR
# Identify and mark outliers
bikeShare['Is_Outlier'] = (bikeShare.humidity < (Q1 - threshold)) | (bikeShare.humidity > (Q3 + threshold))
# Print the outliers
outliers = bikeShare[bikeShare['Is_Outlier']]
print("\033[1mNumber of outliers:\033[0m ", outliers.shape[0])
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR
bikeShare = bikeShare[(bikeShare.humidity >= lower_bound) & (bikeShare.humidity <= upper_bound)]
bikeShare.drop('Is_Outlier', inplace = True, axis = 1)
bikeShare.head()
# Checking for shape
bikeShare.shape
# Plot the boxplot of humidity variable after the removal of outliers.
plt.figure(figsize = [8,2])
sns.boxplot(bikeShare.humidity)
plt.title("Distribution of humidity", fontsize = 12, color = "brown")
plt.show()
# Plot the boxplot of windspeed variable.
plt.figure(figsize = [8,2])
sns.boxplot(bikeShare.windspeed)
plt.title("Distribution of windspeed", fontsize = 12, color = "brown")
plt.show()
# Calculate the IQR (Interquartile Range)
Q1 = bikeShare.windspeed.quantile(0.25)
Q3 = bikeShare.windspeed.quantile(0.75)
IQR = Q3 - Q1
# Define a threshold for outliers
threshold = 1.5 * IQR
# Identify and mark outliers
bikeShare['Is_Outlier'] = (bikeShare.windspeed < (Q1 - threshold)) | (bikeShare.windspeed > (Q3 + threshold))
# Print the outliers
outliers = bikeShare[bikeShare['Is_Outlier']]
print("\033[1mNumber of outliers:\033[0m ", outliers.shape[0])
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR
bikeShare = bikeShare[(bikeShare.windspeed >= lower_bound) & (bikeShare.windspeed <= upper_bound)]
bikeShare.drop('Is_Outlier', inplace = True, axis = 1)
bikeShare.head()
# Checking for shape
bikeShare.shape
# Plot the boxplot of windspeed variable after the removal of outliers.
plt.figure(figsize = [8,2])
sns.boxplot(bikeShare.windspeed)
plt.title("Distribution of windspeed", fontsize = 12, color = "brown")
plt.show()
# Plot the boxplot of casual variable.
plt.figure(figsize = [8,2])
sns.boxplot(bikeShare.casual)
plt.title("Distribution of casual users", fontsize = 12, color = "brown")
plt.show()
# Calculate the IQR (Interquartile Range)
Q1 = bikeShare.casual.quantile(0.25)
Q3 = bikeShare.casual.quantile(0.75)
IQR = Q3 - Q1
# Define a threshold for outliers
threshold = 1.5 * IQR
# Identify and mark outliers
bikeShare['Is_Outlier'] = (bikeShare.casual < (Q1 - threshold)) | (bikeShare.casual > (Q3 + threshold))
# Print the outliers
outliers = bikeShare[bikeShare['Is_Outlier']]
print("\033[1mNumber of outliers:\033[0m ", outliers.shape[0])
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR
bikeShare = bikeShare[(bikeShare.casual >= lower_bound) & (bikeShare.casual <= upper_bound)]
bikeShare.drop('Is_Outlier', inplace = True, axis = 1)
bikeShare.head()
# Checking for shape
bikeShare.shape
# Plot the boxplot of casual variable.
plt.figure(figsize = [8,2])
sns.boxplot(bikeShare.casual)
plt.title("Distribution of casual users", fontsize = 12, color = "brown")
plt.show()# Plot the boxplot of registered variable.
plt.figure(figsize = [8,2])
sns.boxplot(bikeShare.registered)
plt.title("Distribution of registered users", fontsize = 12, color = "brown")
plt.show()
# Creating a df for numerical values
num_var = bikeShare[['temp', 'temp_feel', 'humidity', 'windspeed', 'casual', 'registered']]
# Creating a df for categories
cat_var = bikeShare[['season', 'year', 'month', 'holiday', 'weekday', 'workingday', 'weather_situation', 'count']]
# Exploring numerical columns of the bikeShare dataframe
fig, axes = plt.subplots(nrows=3, ncols=2, figsize=(18, 12))
axes = axes.flatten()
for i, col in enumerate(num_var.columns):
sns.histplot(num_var[col], stat='density', kde=True, kde_kws={"cut": 3}, ax=axes[i])
plt.suptitle('Histograms depicting the distribution of Numerical variables', fontsize=16, color='Green')
plt.show()
# Exploring categorical columns of the bikeShare dataframe
for col in cat_var:
print("\033[1m" + col + "\033[0m")
print(bikeShare[col].value_counts())
print("\n")
# Plotting the categorical variables
fig, axes = plt.subplots(nrows=3, ncols=3, figsize=(14, 14))
# Flatten the axes for easier iteration
axes = axes.flatten()
# Loop through each categorical column and create a bar plot
for i, column in enumerate(cat_var): # Exclude 'cnt'
sns.barplot(x=column, y='count', data=cat_var, ax=axes[i])
axes[i].set_title(f'{column} vs. count')
axes[i].set_xlabel(column)
axes[i].set_ylabel('count')
axes[i].tick_params(axis='x', rotation=45)
# Remove the empty subplot (if any)
if len(cat_var.columns[:-1]) < len(axes.flat):
for j in range(len(cat_var.columns[:-1]), len(axes.flat)):
fig.delaxes(axes.flatten()[j])
# Adjust layout
plt.tight_layout(rect=[0, 0, 1, 0.95])
plt.suptitle('Bar Plots for Categorical Variables Against Target Variable count', fontsize=16, color="Green")
plt.show()
fig, axes = plt.subplots(nrows=3, ncols=2, figsize=(14, 14))
axes = axes.flatten()
for i, col in enumerate(num_var.columns):
sns.scatterplot(data=bikeShare,x=col,y='count',hue = bikeShare['weather_situation'], ax=axes[i])
plt.suptitle('Relationship between features and the target variable w.r.t weather situation', fontsize=16, color="Green", y=0.9)
plt.show()
fig, axes = plt.subplots(nrows=3, ncols=2, figsize=(14, 14))
axes = axes.flatten()
for i, col in enumerate(num_var.columns):
sns.scatterplot(data=bikeShare,x=col,y='count',hue = bikeShare['workingday'], ax=axes[i], palette='inferno')
plt.suptitle('Relationship between features and the target variable w.r.t working day', fontsize=16, color="Green", y=0.9)
plt.show()
fig, axes = plt.subplots(nrows=3, ncols=2, figsize=(14, 14))
axes = axes.flatten()
for i, col in enumerate(num_var.columns):
sns.scatterplot(data=bikeShare,x=col,y='count',hue = bikeShare['year'], ax=axes[i], palette='magma')
plt.suptitle('Relationship between features and the target variable w.r.t year', fontsize=16, color="Green", y=0.9)
plt.show()
# Visualizing numerical variables - pairplot
num_var1 = bikeShare[['temp', 'temp_feel', 'humidity', 'windspeed', 'casual', 'registered', 'count']]
sns.pairplot(num_var1)
plt.suptitle('Pairplot to find corelation between features', fontsize=20, color="Green", y=1.02)
plt.show()
# Let's check the correlation coefficients to see which variables are highly correlated
plt.figure(figsize = (8, 6))
sns.heatmap(num_var1.corr(), annot = True, cmap="YlGnBu")
plt.title('Heatmap to find corelation between features', fontsize=12, color="Green", y=1.02)
plt.show()
# Removing temp_feel.
bikeShare.drop(['temp_feel'],axis=1,inplace=True)
#Statistical Modelling
# Split data into four groups based on weather conditions
group_clear = bikeShare[bikeShare['weather_situation'] == 'Clear']['count']
group_mist = bikeShare[bikeShare['weather_situation'] == 'Mist']['count']
group_light_snow = bikeShare[bikeShare['weather_situation'] == 'Light Snow']['count']
# Perform one-way ANOVA
statistic, p_value = f_oneway(group_clear, group_mist, group_light_snow)
# Define significance level
alpha = 0.05
# Print the results
print(f'\033[1mANOVA Statistic:\033[0m {statistic}')
print(f'\033[1mP-value:\033[0m {p_value}')
# Compare p-value with significance level
if p_value < alpha:
print('\033[1mReject the null hypothesis: Different weather conditions affect bike rentals differently.\033[0m')
else:
print('\033[1mFail to reject the null hypothesis: No significant impact of weather conditions on bike rentals.\033[0m')
# Visualize the distribution of rentals on working and non-working days
plt.figure(figsize=(10, 6))
sns.histplot(data=bikeShare, x='count', hue='weather_situation', bins=30, kde=True)
plt.title('Distribution of Bike Rentals on different weather situations', color='green')
plt.xlabel('Count of Bike Rentals')
plt.ylabel('Frequency')
plt.legend(title='Weather situation', labels=['Clear', 'Mist', 'Light Snow'])
plt.show()
# Split data into two groups: working days and non-working days
working_days = bikeShare[bikeShare['workingday'] == 1]['count']
non_working_days = bikeShare[bikeShare['workingday'] == 0]['count']
# Perform independent t-test
statistic, p_value = ttest_ind(working_days, non_working_days)
# Define significance level
alpha = 0.05
# Print the results
print(f'\033[1mT-test Statistic:\033[0m {statistic}')
print(f'\033[1mP-value:\033[0m {p_value}')
# Compare p-value with significance level
if p_value < alpha:
print('\033[1mReject the null hypothesis: There are significant differences in bike rentals between working and non-working days.\033[0m')
else:
print('\033[1mFail to reject the null hypothesis: \033[1mNo significant differences in bike rentals between working and non-working days.\033[0m')
# Visualize the distribution of rentals on working and non-working days
plt.figure(figsize=(10, 6))
sns.histplot(data=bikeShare, x='count', hue='workingday', bins=30, kde=True)
plt.title('Distribution of Bike Rentals on Working and Non-Working Days', color='green')
plt.xlabel('Count of Bike Rentals')
plt.ylabel('Frequency')
plt.legend(title='Working Day', labels=['Non-Working Day', 'Working Day'])
plt.show()
# Split data into two groups: holidays and regular days
holidays = bikeShare[bikeShare['holiday'] == 1]['count']
regular_days = bikeShare[bikeShare['holiday'] == 0]['count']
# Perform independent t-test
statistic, p_value = ttest_ind(holidays, regular_days)
# Define significance level
alpha = 0.05
# Print the results
print(f'\033[1mT-test Statistic:\033[0m {statistic}')
print(f'\033[1mP-value:\033[0m {p_value}')
# Compare p-value with significance level
if p_value < alpha:
print('\033[1mReject the null hypothesis: There are significant differences in bike rentals between holidays and regular days.\033[0m')
else:
print('\033[1mFail to reject the null hypothesis: No significant differences in bike rentals between holidays and regular days.\033[0m')
# Visualize the distribution of rentals on holidays and regular days
plt.figure(figsize=(10, 6))
sns.histplot(data=bikeShare, x='count', hue='holiday', bins=30, kde=True)
plt.title('Distribution of Bike Rentals on Holidays and Regular Days', color='green')
plt.xlabel('Count of Bike Rentals')
plt.ylabel('Frequency')
plt.legend(title='Holiday', labels=['Regular Day', 'Holiday'])
plt.show()
# Test the correlation between temperature and bike rentals using Spearman's rank correlation
correlation, p_value = spearmanr(bikeShare['temp'], bikeShare['count'])
# Define significance level
alpha = 0.05
# Print the results
print(f'\033[1mSpearman\'s Rank Correlation:\033[0m {correlation}')
print(f'\033[1mP-value:\033[0m {p_value}')
# Compare p-value with significance level
if p_value < alpha:
print('\033[1mReject the null hypothesis: There is a significant correlation between temperature and bike rentals.\033[0m')
else:
print('\033[1mFail to reject the null hypothesis: No significant correlation between temperature and bike rentals.\033[0m')
# Visualize the relationship between temperature and bike rentals
plt.figure(figsize=(10, 6))
sns.scatterplot(data=bikeShare, x='temp', y='count')
plt.title('Relationship Between Temperature and Bike Rentals', color='green')
plt.xlabel('Temperature')
plt.ylabel('Count of Bike Rentals')
plt.show()
# Creating dummies
status = pd.get_dummies(bikeShare[['season', 'year', 'month', 'weekday', 'weather_situation']], drop_first=True)
status.head()
# concat the status dataframe created with our bikeShare_new dataframe
bikeShare_new = pd.concat([bikeShare, status], axis = 1)
# Checking the concatinated dataframe
bikeShare_new.head()
# Drop 'season', 'mnth', 'weekday', 'weathersit' as we have created the dummies for it
drop_cols = ['season', 'year', 'month', 'weekday', 'weather_situation']
bikeShare_new.drop(drop_cols, axis = 1, inplace = True)
from sklearn.model_selection import train_test_split
# We specify random_state so that the train and test data set always have the same rows, respectively
df_train, df_test = train_test_split(bikeShare_new, train_size = 0.7, test_size = 0.3, random_state = 100)
scaler = MinMaxScaler()
# Apply scaler() to all the columns except the 'yes-no' and 'dummy' variables
num_vars = ['temp', 'humidity', 'windspeed', 'casual', 'registered']
df_train[num_vars] = scaler.fit_transform(df_train[num_vars])
df_test[num_vars] = scaler.transform(df_test[num_vars])
# Let's check the correlation coefficients to see which variables are highly correlated
plt.figure(figsize = (25, 20))
sns.heatmap(df_train.corr(), annot = True, cmap="YlGnBu")
plt.show()
X_train = df_train.drop('count', axis=1)
y_train = df_train['count']
X_test = df_test.drop('count', axis=1)
y_test = df_test['count']
# Linear Regression
# Create a Regression Model instances and fitting the model on the training data
# Linear Regression Model
print("\033[1mLinear Regression Model\033[0m")
lr = LinearRegression()
lr.fit(X_train,y_train)
y_pred_linear = lr.predict(X_test)
print('Predicted Linear Regression values are ', y_pred_linear[1:5])
mse = mean_squared_error(y_test,y_pred_linear)
print(f"Mean Squared Error: {mse}")
rmse = mse**0.5
print(f"Root Mean Squared Error: {rmse}")
mae = mean_absolute_error(y_test,y_pred_linear)
print(f"Mean Absolute Error: {mae}")
r2score=r2_score(y_test,y_pred_linear)
print(f"R^2 Score: {r2score}")
print("\n")
# Lasso Regression Model
print("\033[1mLasso Regression Model\033[0m")
lasso = Lasso(alpha=0.5)
lasso.fit(X_train,y_train)
y_pred_lasso = lasso.predict(X_test)
print('Predicted Lasso Regression values are ', y_pred_lasso[1:5])
mse = mean_squared_error(y_test,y_pred_lasso)
print(f"Mean Squared Error: {mse}")
rmse = mse**0.5
print(f"Root Mean Squared Error: {rmse}")
mae = mean_absolute_error(y_test,y_pred_lasso)
print(f"Mean Absolute Error: {mae}")
r2score=r2_score(y_test,y_pred_lasso)
print(f"R^2 Score: {r2score}")
print("\n")
# Ridge Regression Model
print("\033[1mRidge Regression Model\033[0m")
ridge = Ridge(alpha=1)
ridge.fit(X_train,y_train)
y_pred_ridge=ridge.predict(X_test)
print('Predicted Ridge Regression values are ', y_pred_ridge[1:5])
mse = mean_squared_error(y_test,y_pred_ridge)
print(f"Mean Squared Error: {mse}")
rmse = mse**0.5
print(f"Root Mean Squared Error: {rmse}")
mae = mean_absolute_error(y_test,y_pred_ridge)
print(f"Mean Absolute Error: {mae}")
r2score=r2_score(y_test,y_pred_ridge)
print(f"R^2 Score: {r2score}")
print("\n")
# Elastic Net Regression Model
print("\033[1mElasticNet Regression Model\033[0m")
elastic_net = ElasticNet(alpha=0.1, l1_ratio=0.5)
elastic_net.fit(X_train,y_train)
y_pred_elastic = elastic_net.predict(X_test)
print('Predicted ElasticNet Regression values are ', y_pred_elastic[1:5])
mse = mean_squared_error(y_test,y_pred_elastic)
print(f"Mean Squared Error: {mse}")
rmse = mse**0.5
print(f"Root Mean Squared Error: {rmse}")
mae = mean_absolute_error(y_test,y_pred_elastic)
print(f"Mean Absolute Error: {mae}")
r2score=r2_score(y_test,y_pred_elastic)
print(f"R^2 Score: {r2score}")
#Hyperparameter tunning
# ElasticNet Regression
# Define the grid of hyperparameters 'param_grid'
param_grid = {
'alpha': [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1],
'l1_ratio': [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]
}
# Initialize GridSearchCV with the required parameters
grid_model_result = GridSearchCV(estimator=ElasticNet(),
param_grid=param_grid,
cv=10).fit(X_train,y_train)
# Print results
print(f"Best: {grid_model_result.best_score_} using {grid_model_result.best_params_}")
# Ridge Regression
# Defining list of alphas
alphas = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]
# Create a ridge regressor object that does cross-validation
ridge_cv = RidgeCV(alphas=alphas)
# Fit it to our training data
ridge_cv.fit(X_train,y_train)
# Get predictions for test set.
y_pred_ridgecv=ridge_cv.predict(X_test)
print('Ridge CV Model Mean Squared Error:', mean_squared_error(y_test,y_pred_ridgecv))
print('Best Alpha after Cross Validation :', ridge_cv.alpha_)
# Create a Regression Model instances and fitting the model on the training data
# Linear Regression Model
lr = LinearRegression()
lr.fit(X_train,y_train)
y_pred_linear = lr.predict(X_test)
print("\033[1mLinear Regression Model\033[0m")
print('Predicted Linear Regression values are ', y_pred_linear[1:5])
# Lasso Regression Model
lasso = Lasso(alpha=0)
lasso.fit(X_train,y_train)
y_pred_lasso = lasso.predict(X_test)
print("\n")
print("\033[1mLasso Regression Model\033[0m")
print('Predicted Lasso Regression values are ', y_pred_lasso[1:5])
# Ridge Regression Model
ridge = Ridge(alpha=0.1)
ridge.fit(X_train,y_train)
y_pred_ridge=ridge.predict(X_test)
print("\n")
print("\033[1mRidge Regression Model\033[0m")
print('Predicted Ridge Regression values are ', y_pred_ridge[1:5])
# Elastic Net Regression Model
elastic_net = ElasticNet(alpha=0.1, l1_ratio=1)
elastic_net.fit(X_train,y_train)
y_pred_elastic = elastic_net.predict(X_test)
print("\n")
print("\033[1mElasticNet Regression Model\033[0m")
print('Predicted ElasticNet Regression values are ', y_pred_elastic[1:5])
# Calculate evaluation metrics for each model
model_names = ["Linear Regression", "Lasso Regression", "Ridge Regression", "Elastic Net Regression"]
models = [lr, lasso, ridge, elastic_net]
predictions = [y_pred_linear, y_pred_lasso, y_pred_ridge, y_pred_elastic]
metrics = []
for name, model, y_pred in zip(model_names, models, predictions):
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)
mae = mean_absolute_error(y_test,y_pred)
metrics.append([name, mse, rmse, mae, r2])
# Create a DataFrame to display the metrics
df_metrics = pd.DataFrame(metrics, columns=["Model", "Mean Squared Error (MSE)", "Root Mean Sqaure Error (RMSE)", "Mean Absolute Error (MAE)", "R-squared (R^2)"])
# Display the table
print(df_metrics)
df_met = df_metrics.drop(columns=["Model"])
df_metrics.set_index(df_met.columns, inplace=True)
# Custom x-axis labels
custom_labels = ["Linear", "Lasso", "Ridge", "Elastic Net"]
# Plotting the metrics
fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(12, 10))
fig.suptitle('Model Evaluation Metrics')
# Plotting Mean Squared Error (MSE)
df_metrics['Mean Squared Error (MSE)'].plot(kind='line', marker='o', ax=axes[0, 0], grid=True)
axes[0, 0].set_ylabel('MSE')
axes[0, 0].set_xticks(range(len(custom_labels)))
axes[0, 0].set_xticklabels(custom_labels)
# Plotting Root Mean Square Error (RMSE)
df_metrics['Root Mean Sqaure Error (RMSE)'].plot(kind='line', marker='o', ax=axes[0, 1], grid=True)
axes[0, 1].set_ylabel('RMSE')
axes[0, 1].set_xticks(range(len(custom_labels)))
axes[0, 1].set_xticklabels(custom_labels)
# Plotting Mean Absolute Error (MAE)
df_metrics['Mean Absolute Error (MAE)'].plot(kind='line', marker='o', ax=axes[1, 0], grid=True)
axes[1, 0].set_ylabel('MAE')
axes[1, 0].set_xticks(range(len(custom_labels)))
axes[1, 0].set_xticklabels(custom_labels)
# Plotting R-squared (R^2)
df_metrics['R-squared (R^2)'].plot(kind='line', marker='o', ax=axes[1, 1], grid=True)
axes[1, 1].set_ylabel('R^2')
axes[1, 1].set_xticks(range(len(custom_labels)))
axes[1, 1].set_xticklabels(custom_labels)
plt.tight_layout(rect=[0, 0, 1, 0.96]) # Adjust the layout
plt.show()
# Plotting Regression Graph
plt.scatter(y_test, y_pred_linear)
plt.xlabel("Actual Count")
plt.ylabel("Predicted Count")
plt.title("Linear Regression: Actual vs. Predicted Count")
plt.show()
fig, axes = plt.subplots(nrows=3, ncols=2, figsize=(18, 12))
axes = axes.flatten()
plot_data = pd.DataFrame({'Actual Count': y_test, 'Predicted Count': y_pred_linear})
numerical_cols = ['temp', 'humidity', 'windspeed', 'casual', 'registered']
# Plotting individual regression plots for each numerical variable
for i, column in enumerate(numerical_cols):
sns.regplot(x=X_test[column], y=y_test, scatter_kws={'s': 15}, line_kws={'color': 'red'}, ax=axes[i])
plt.title(f"Linear Regression: Actual vs. Predicted Count for {column}")
plt.xlabel(column)
plt.ylabel("Count")
# Remove the empty subplot (if any)
if len(numerical_cols) < len(axes.flat):
for j in range(len(numerical_cols), len(axes.flat)):
fig.delaxes(axes.flatten()[j])
plt.suptitle('Linear Regression: Actual vs. Predicted Count for Numerical Variables', fontsize=16, color='Green')
plt.show()
# Coefficients for each feature
coefficients = lr.coef_
feature_names = X_train.columns
coef_df = pd.DataFrame({'Feature': feature_names, 'Coefficient': coefficients})
sorted_coef_df = coef_df.sort_values(by='Coefficient', ascending=False)
# Intercept
intercept = lr.intercept_
print("\033[1mCoefficients:\033[0m")
print(sorted_coef_df)
print("\n")
print("\033[1mIntercept:\033[0m", intercept)
